home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gp_amiga.c < prev    next >
C/C++ Source or Header  |  1997-07-05  |  22KB  |  907 lines
  1. /* Copyright (C) 1989, 1992, 1993, 1994 Aladdin Enterprises.  All rights reserved.
  2.  
  3.   This file is part of Aladdin Ghostscript.
  4.  
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.  
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gp_amiga.c */
  20. /* Amiga-specific routines for Ghostscript */
  21. #include <dos/dosextens.h>
  22. #include <graphics/gfxbase.h>
  23. #include <intuition/intuitionbase.h>
  24.  
  25. #include <proto/dos.h>
  26. #include <proto/exec.h>
  27.  
  28. #include "dirent_.h"
  29. #include "stat_.h"
  30. #include "string_.h"
  31. #include "time_.h"
  32. #include "gx.h"
  33. #include "gp.h"
  34. #include "gsexit.h"
  35. #include "gsstruct.h"
  36. #include "gsutil.h"
  37.  
  38. #include <signal.h>
  39. #include <stdlib.h>
  40. #include <unistd.h>
  41. #include <sys/param.h>    /* for MAXPATHLEN */
  42.  
  43. #if defined(mc68020)
  44.  #ifdef __HAVE_68881__
  45.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68020/FPU version\r\n";
  46.  #else
  47.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68020 version\r\n";
  48.  #endif    /* __HAVE_68881__ */
  49. #elif defined(mc68030)
  50.  #ifdef __HAVE_68881__
  51.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68030/FPU version\r\n";
  52.  #else
  53.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68030 version\r\n";
  54.  #endif    /* __HAVE_68881__ */
  55. #elif defined(mc68040)
  56.  #ifdef __HAVE_68881__
  57.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68040/FPU version\r\n";
  58.  #else
  59.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68040 version\r\n";
  60.  #endif    /* __HAVE_68881__ */
  61. #elif defined(mc68060)
  62.  #ifdef __HAVE_68881__
  63.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68060/FPU version\r\n";
  64.  #else
  65.   STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97) MC68060 version\r\n";
  66.  #endif    /* __HAVE_68881__ */
  67. #else
  68. STATIC STRPTR VersTag = "$VER: gs 5.01 (22.06.97)\r\n";
  69. #endif    /* mc68020 */
  70.  
  71. struct IntuitionBase    *IntuitionBase;
  72. struct GfxBase        *GfxBase;
  73. struct Library        *LayersBase,
  74.             *IFFParseBase,
  75.             *AslBase,
  76.             *UtilityBase;
  77. /*struct DosLibrary *DOSBase;
  78. struct MathIEEEBase *MathIeeeDoubBasBase;*/
  79.  
  80. /* Cleanup routine, as called by atexit() trap */
  81. void
  82. cleanup(void)
  83. {
  84.     extern void devcleanup(void);
  85.  
  86.     devcleanup();
  87.  
  88.     if(IFFParseBase)
  89.     {
  90.         CloseLibrary(IFFParseBase);
  91.  
  92.         IFFParseBase = NULL;
  93.     }
  94.  
  95.     if(AslBase)
  96.     {
  97.         CloseLibrary(AslBase);
  98.  
  99.         AslBase = NULL;
  100.     }
  101.  
  102.     if(UtilityBase)
  103.     {
  104.         CloseLibrary(UtilityBase);
  105.  
  106.         UtilityBase = NULL;
  107.     }
  108.  
  109.     if(LayersBase)
  110.     {
  111.         CloseLibrary(LayersBase);
  112.  
  113.         LayersBase = NULL;
  114.     }
  115.  
  116.     if(GfxBase)
  117.     {
  118.         CloseLibrary((struct Library *)GfxBase);
  119.  
  120.         GfxBase = NULL;
  121.     }
  122.  
  123.     if(IntuitionBase)
  124.     {
  125.         CloseLibrary((struct Library *)IntuitionBase);
  126.  
  127.         IntuitionBase = NULL;
  128.     }
  129. }
  130.  
  131. void
  132. signal_handler(int signal)
  133. {
  134.     fprintf(stderr,"*** BREAK: Ghostscript\a\n");
  135.  
  136.     gs_exit(1);
  137. }
  138.  
  139. /* Do platform-dependent initialization. */
  140. void
  141. gp_init(void)
  142. {
  143.     atexit(cleanup);
  144.  
  145.     signal(SIGINT,signal_handler);
  146.     
  147.     if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37)))
  148.     {
  149.         eprintf("Ghostscript: cannot open intuition.library v37\n");
  150.  
  151.         exit(20);
  152.     }
  153.     
  154.     if(!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",37)))
  155.     {
  156.         eprintf("Ghostscript: cannot open graphics.library v37\n");
  157.  
  158.         exit(20);
  159.     }
  160.  
  161.     if(!(LayersBase = OpenLibrary("layers.library",37)))
  162.     {
  163.         eprintf("Ghostscript: cannot open layers.library v37\n");
  164.  
  165.         exit(20);
  166.     }
  167.  
  168.     if(!(UtilityBase = OpenLibrary("utility.library",37)))
  169.     {
  170.         eprintf("Ghostscript: cannot open utility.library v37\n");
  171.  
  172.         exit(20);
  173.     }
  174.  
  175.     if(!(IFFParseBase = OpenLibrary("iffparse.library",37)))
  176.     {
  177.         eprintf("Ghostscript: cannot open iffparse.library v37\n");
  178.  
  179.         exit(20);
  180.     }
  181.  
  182.     AslBase = OpenLibrary("asl.library",38);
  183. }
  184.  
  185. /* Do platform-dependent cleanup. */
  186. void
  187. gp_exit(int exit_status, int code)
  188. {
  189.     cleanup();
  190. }
  191.  
  192. /* Exit the program. */
  193. void
  194. gp_do_exit(int exit_status)
  195. {    exit(exit_status);
  196. }
  197.  
  198. /* ------ Miscellaneous ------ */
  199.  
  200. /*
  201.  * Get the string corresponding to an OS error number.
  202.  * If no string is available, return NULL.  The caller may assume
  203.  * the string is allocated statically and permanently.
  204.  */
  205. const char *
  206. gp_strerror(int errnum)
  207. {    return (strerror(errnum));
  208. }
  209.  
  210. /* ------ Date and time ------ */
  211.  
  212. /* Read the current time (in seconds since Jan. 1, 1970) */
  213. /* and fraction (in nanoseconds). */
  214. void
  215. gp_get_realtime(long *pdt)
  216. {
  217. #if defined(IXEMUL)
  218.     struct timeval tp;
  219.  
  220.  #if gettimeofday_no_timezone            /* older versions of SVR4 */
  221.     {    if ( gettimeofday(&tp) == -1 )
  222.           {    lprintf("Ghostscript: gettimeofday failed!\n");
  223.             gs_exit(1);
  224.           }
  225.     }
  226.  #else                        /* All other systems */
  227.     {    struct timezone tzp;
  228.         if ( gettimeofday(&tp, &tzp) == -1 )
  229.           {    lprintf("Ghostscript: gettimeofday failed!\n");
  230.             gs_exit(1);
  231.           }
  232.     }
  233.  #endif
  234.     /* tp.tv_sec is #secs since Jan 1, 1970 */
  235.     pdt[0] = tp.tv_sec;
  236.  
  237.     /* Some Unix systems (e.g., Interactive 3.2 r3.0) return garbage */
  238.     /* in tp.tv_usec.  Try to filter out the worst of it here. */
  239.     pdt[1] = tp.tv_usec >= 0 && tp.tv_usec < 1000000 ? tp.tv_usec*1000 : 0;
  240.  
  241. #else
  242.     LONG secs, micros;
  243.  
  244.     CurrentTime(&secs, µs);
  245.  
  246.     pdt[0] = secs;
  247.     pdt[1] = micros*1000;
  248.  
  249. #endif
  250. #ifdef DEBUG_CLOCK
  251.     printf("tp.tv_sec = %d  tp.tv_usec = %d  pdt[0] = %ld  pdt[1] = %ld\n",
  252.         tp.tv_sec, tp.tv_usec, pdt[0], pdt[1]);
  253. #endif
  254. }
  255.  
  256. /* Read the current user CPU time (in seconds) */
  257. /* and fraction (in nanoseconds).  */
  258. void
  259. gp_get_usertime(long *pdt)
  260. {
  261. #if use_times_for_usertime
  262.     LONG secs, micros;
  263.  
  264.     CurrentTime(&secs, µs);
  265.  
  266.     pdt[0] = secs;
  267.     pdt[1] = micros*1000;
  268. #else
  269.     gp_get_realtime(pdt);    /* Use an approximation on other hosts.  */
  270. #endif
  271. }
  272.  
  273. /* ------ Screen management ------ */
  274.  
  275. /* Get the environment variable that specifies the display to use. */
  276. const char *
  277. gp_getenv_display(void)
  278. {    return getenv("DISPLAY");
  279. }
  280.  
  281. /* ------ Printer accessing ------ */
  282.  
  283. /* Open a connection to a printer.  A null file name means use the */
  284. /* standard printer connected to the machine, if any. */
  285. /* "|command" opens an output pipe. */
  286. /* Return NULL if the connection could not be opened. */
  287. FILE *
  288. gp_open_printer(char *fname, int binary_mode)
  289. {
  290. #ifndef IXEMUL
  291.     return
  292.       (strlen(fname) == 0 ?
  293.        gp_open_scratch_file(gp_scratch_file_name_prefix, fname, "w") :
  294.        fname[0] == '|' ?
  295.        NULL :
  296.        fopen(fname, "w"));
  297. #else
  298.     return
  299.       (strlen(fname) == 0 ?
  300.        gp_open_scratch_file(gp_scratch_file_name_prefix, fname, "w") :
  301.        fname[0] == '|' ?
  302.        popen(fname + 1, "w") :
  303.        fopen(fname, "w"));
  304. #endif
  305. }
  306.  
  307. /* Close the connection to the printer. */
  308. void
  309. gp_close_printer(FILE *pfile, const char *fname)
  310. {
  311. #ifndef IXEMUL
  312.     fclose(pfile);
  313. #else
  314.     if ( fname[0] == '|' )
  315.         pclose(pfile);
  316.     else
  317.         fclose(pfile);
  318. #endif
  319. }
  320.  
  321. /* ------ File name syntax ------ */
  322.  
  323. /* Define the character used for separating file names in a list. */
  324. const char gp_file_name_list_separator = ',';
  325.  
  326. /* Define the string to be concatenated with the file mode */
  327. /* for opening files without end-of-line conversion. */
  328. const char gp_fmode_binary_suffix[] = "";
  329. /* Define the file modes for binary reading or writing. */
  330. const char gp_fmode_rb[] = "r";
  331. const char gp_fmode_wb[] = "w";
  332.  
  333. /* Answer whether a file name contains a directory/device specification, */
  334. /* i.e. is absolute (not directory- or device-relative). */
  335. int
  336. gp_file_name_is_absolute(const char *fname, uint len)
  337. {
  338.     int i;
  339.  
  340.     for(i = 0 ; i < len ; i++)
  341.     {
  342.         if(fname[i] == ':')
  343.             return(1);
  344.     }
  345.  
  346.     return(0);
  347. }
  348.  
  349. /* Answer the string to be used for combining a directory/device prefix */
  350. /* with a base file name.  The file name is known to not be absolute. */
  351. const char *
  352. gp_file_name_concat_string(const char *prefix, uint plen, const char *fname, uint len)
  353. {
  354. #ifdef IXEMUL
  355.     if(plen > 0 && (prefix[plen - 1] == '/' || prefix[plen - 1] == ':'))
  356.         return("");
  357.     else
  358.         return("/");
  359. #else
  360.     if(plen > 0)
  361.         if(prefix[plen - 1] == '/' || prefix[plen - 1] == ':')
  362.             return("");
  363.         else
  364.             return("/");
  365.     else
  366.         return("");
  367. #endif
  368. }
  369.  
  370. /* ------ File naming and accessing ------ */
  371.  
  372. /* Define the default scratch file name prefix. */
  373. const char gp_scratch_file_name_prefix[] = "T:gs_";
  374.  
  375. /* Define the name of the null output file. */
  376. #ifdef IXEMUL
  377. const char gp_null_file_name[] = "/dev/null";
  378. #else
  379. const char gp_null_file_name[] = "NIL:";
  380. #endif
  381.  
  382. /* Define the name that designates the current directory. */
  383. #ifdef IXEMUL
  384. const char gp_current_directory_name[] = ".";
  385. #else
  386. const char gp_current_directory_name[] = "";
  387. #endif
  388.  
  389. /* Create and open a scratch file with a given name prefix. */
  390. /* Write the actual file name at fname. */
  391. FILE *
  392. gp_open_scratch_file(const char *prefix, char *fname, const char *mode)
  393. {
  394. #ifndef IXEMUL
  395.     char *temp;
  396.     char temp2[100];
  397.     struct Task *thistask;
  398.     LONG secs, micros;
  399. #endif
  400.  
  401.     strcpy(fname,prefix);
  402.     /* Prevent trailing X's in path from being converted by mktemp. */
  403.     if ( *fname != 0 && fname[strlen(fname) - 1] == 'X' )
  404.         strcat(fname, "-");
  405. #ifdef IXEMUL
  406.     strcat(fname, "XXXXXX");
  407. #else
  408.     CurrentTime(&secs, µs);
  409.     sprintf(temp2,"%08lx_%08lx_%08lx",FindTask(NULL), secs, micros);
  410. /* this looks stupid but a reasonable chance exists that you end up with the
  411.    same time if scratch files are opened fast enough
  412. */
  413.     Delay(3);
  414.     strcat(fname, temp2);
  415. #endif
  416. #ifdef IXEMUL
  417.     mktemp(fname);
  418. #endif
  419.     return fopen(fname, mode);
  420. }
  421.  
  422. /* Open a file with the given name, as a stream of uninterpreted bytes. */
  423. FILE *
  424. gp_fopen(const char *fname, const char *mode)
  425. {    return fopen(fname, mode);
  426. }
  427.  
  428. /* ------ File enumeration ------ */
  429.  
  430. /* Thanks to Fritz Elfert (Fritz_Elfert@wue.maus.de) for */
  431. /* the original version of the following code, and Richard Mlynarik */
  432. /* (mly@adoc.xerox.com) for an improved version. */
  433.  
  434. typedef struct dirstack_s dirstack;
  435. struct dirstack_s {
  436.     dirstack *next;
  437.     DIR *entry;
  438. };
  439. gs_private_st_ptrs1(st_dirstack, dirstack, "dirstack",
  440.   dirstack_enum_ptrs, dirstack_reloc_ptrs, next);
  441.  
  442. struct file_enum_s {
  443.     DIR *dirp;        /* pointer to current open directory   */
  444.     char *pattern;        /* original pattern                    */
  445.     char *work;        /* current path                        */
  446.     int worklen;            /* strlen (work)               */
  447.     dirstack *dstack;    /* directory stack                     */
  448.     int patlen;
  449.     int pathead;            /* how much of pattern to consider
  450.                  *  when listing files in current directory */
  451.     bool first_time;
  452.     gs_memory_t *memory;
  453. };
  454. gs_private_st_ptrs3(st_file_enum, struct file_enum_s, "file_enum",
  455.   file_enum_enum_ptrs, file_enum_reloc_ptrs, pattern, work, dstack);
  456.  
  457. /* Private procedures */
  458.  
  459. /* Do a wild-card match. */
  460. #ifdef DEBUG
  461. private bool
  462. wmatch(const byte *str, uint len, const byte *pstr, uint plen,
  463.   const string_match_params *psmp)
  464. {    bool match = string_match(str, len, pstr, plen, psmp);
  465.     if ( gs_debug_c('e') )
  466.       { dputs("[e]string_match(\"");
  467.         fwrite(str, 1, len, dstderr);
  468.         dputs("\", \"");
  469.         fwrite(pstr, 1, plen, dstderr);
  470.         dprintf1("\") = %s\n", (match ? "TRUE" : "false"));
  471.       }
  472.     return match;
  473. }
  474. #define string_match wmatch
  475. #endif
  476.  
  477. /* Search a string backward for a character. */
  478. /* (This substitutes for strrchr, which some systems don't provide.) */
  479. private char *
  480. rchr(char *str, char ch, int len)
  481. {    register char *p = str + len;
  482.     while ( p > str )
  483.       if ( *--p == ch ) return p;
  484.     return 0;
  485. }
  486.  
  487. /* Pop a directory from the enumeration stack. */
  488. private bool
  489. popdir(file_enum *pfen)
  490. {    dirstack *d = pfen->dstack;
  491.     if ( d == 0 )
  492.       return false;
  493.     pfen->dirp = d->entry;
  494.     pfen->dstack = d->next;
  495.     gs_free_object(pfen->memory, d, "gp_enumerate_files(popdir)");
  496.     return true;
  497. }
  498.  
  499. /* Initialize an enumeration. */
  500. file_enum *
  501. gp_enumerate_files_init(const char *pat, uint patlen, gs_memory_t *mem)
  502. {    file_enum *pfen;
  503.     char *p;
  504.     char *work;
  505.  
  506.     /* Reject attempts to enumerate paths longer than the */
  507.     /* system-dependent limit. */
  508.     if ( patlen > MAXPATHLEN )
  509.         return 0;
  510.  
  511.     /* Reject attempts to enumerate with a pattern containing zeroes. */
  512.     {    const char *p1;
  513.         for (p1 = pat; p1 < pat + patlen; p1++)
  514.             if (*p1 == 0) return 0;
  515.     }
  516.         /* >>> Should crunch strings of repeated "/"'s in pat to a single "/"
  517.          * >>>  to match stupid unix filesystem "conventions" */
  518.  
  519.     pfen = gs_alloc_struct(mem, file_enum, &st_file_enum,
  520.                    "gp_enumerate_files");
  521.     if (pfen == 0)
  522.         return 0;
  523.  
  524.     /* pattern and work could be allocated as strings, */
  525.     /* but it's simpler for GC and freeing to allocate them as bytes. */
  526.  
  527.     pfen->pattern =
  528.       (char *)gs_alloc_bytes(mem, patlen + 1,
  529.                  "gp_enumerate_files(pattern)");
  530.     if (pfen->pattern == 0)
  531.         return 0;
  532.     memcpy(pfen->pattern, pat, patlen);
  533.     pfen->pattern[patlen] = 0;
  534.  
  535.     work = (char *)gs_alloc_bytes(mem, MAXPATHLEN+1,
  536.                       "gp_enumerate_files(work)");
  537.     if (work == 0)
  538.         return 0;
  539.     pfen->work = work;
  540.  
  541.     p = work;
  542.     memcpy(p, pat, patlen);
  543.     p += patlen;
  544.     *p = 0;
  545.  
  546.     /* Remove directory specifications beyond the first wild card. */
  547.     /* Some systems don't have strpbrk, so we code it open. */
  548.     p = pfen->work;
  549.     while ( !(*p == '*' || *p == '?' || *p == 0) ) p++;
  550.     while ( !(*p == '/' || *p == 0) ) p++;
  551.     if ( *p == '/' )
  552.       *p = 0;
  553.         /* Substring for first wildcard match */
  554.         pfen->pathead = p - work;
  555.  
  556.     /* Select the next higher directory-level. */
  557.         p = rchr(work, '/', p - work);
  558.         if (!p)
  559.       {    /* No directory specification */
  560.         work[0] = 0;
  561.         pfen->worklen = 0;
  562.       }
  563.         else
  564.       {    if (p == work)
  565.           {    /* Root directory -- don't turn "/" into "" */
  566.             p++;
  567.           }
  568.         *p = 0;
  569.         pfen->worklen = p - work;
  570.       }
  571.  
  572.     pfen->memory = mem;
  573.     pfen->dstack = 0;
  574.     pfen->first_time = true;
  575.     pfen->patlen = patlen;
  576.     return pfen;
  577. }
  578.  
  579. /* Enumerate the next file. */
  580. uint
  581. gp_enumerate_files_next(file_enum *pfen, char *ptr, uint maxlen)
  582. {    dir_entry *de;
  583.     char *work = pfen->work;
  584.     int worklen = pfen->worklen;
  585.     char *pattern = pfen->pattern;
  586.     int pathead = pfen->pathead;
  587.     int len;
  588.     struct stat stbuf;
  589.  
  590.     if ( pfen->first_time )
  591.       {    pfen->dirp = ((worklen == 0) ? opendir(".") : opendir(work));
  592.         if_debug1('e', "[e]file_enum:First-Open '%s'\n", work);
  593.         pfen->first_time = false;
  594.         if (pfen->dirp == 0)    /* first opendir failed */
  595.           {    gp_enumerate_files_close(pfen);
  596.             return ~(uint)0;
  597.           }
  598.       }
  599.  
  600.  top:    de = readdir(pfen->dirp);
  601.     if (de == 0)
  602.       {    /* No more entries in this directory */
  603.         char *p;
  604.  
  605.         if_debug0('e', "[e]file_enum:Closedir\n");
  606.         closedir(pfen->dirp);
  607.         /* Back working directory and matching pattern up one level */
  608.         p = rchr(work,'/', worklen);
  609.         if (p != 0)
  610.           {    if (p == work) p++;
  611.             *p = 0;
  612.             worklen = p - work;
  613.           }
  614.                 else
  615.                   worklen = 0;
  616.         p = rchr(pattern,'/', pathead);
  617.         if (p != 0)
  618.           pathead = p - pattern;
  619.         else
  620.           pathead = 0;
  621.  
  622.         if (popdir(pfen))
  623.           {    /* Back up the directory tree. */
  624.             if_debug1('e', "[e]file_enum:Dir popped '%s'\n", work);
  625.             goto top;
  626.           }
  627.         else
  628.           {    if_debug0('e', "[e]file_enum:Dirstack empty\n");
  629.             gp_enumerate_files_close(pfen);
  630.             return ~(uint)0;
  631.           }
  632.       }
  633.  
  634.     /* Skip . and .. */
  635.     len = strlen(de->d_name);
  636.     if (len <= 2 && (!strcmp(de->d_name,".") || !strcmp(de->d_name,"..") ))
  637.       goto top;
  638.     if (len + worklen + 1 > MAXPATHLEN)
  639.       /* Should be an error, I suppose */
  640.       goto top;
  641.     if (worklen == 0)
  642.       {    /* "Current" directory (evil un*x kludge) */
  643.         memcpy(work, de->d_name, len + 1);
  644.       }
  645.     else if (worklen == 1 && work[0] == '/')
  646.       {    /* Root directory */
  647.         memcpy(work + 1, de->d_name, len + 1);
  648.         len = len + 1;
  649.       }
  650.     else
  651.       {    work[worklen] = '/';
  652.         memcpy(work + worklen + 1, de->d_name, len + 1);
  653.         len = worklen + 1 + len;
  654.       }
  655.  
  656.     /* Test for a match at this directory level */
  657.     if (!string_match((byte *)work, len, (byte *)pattern, pathead, NULL))
  658.       goto top;
  659.  
  660.     /* Perhaps descend into subdirectories */
  661.     if (pathead < pfen->patlen)
  662.       {    DIR *dp;
  663.  
  664.         if (((stat(work,&stbuf) >= 0)
  665.              ? !stat_is_dir(stbuf)
  666.              /* Couldn't stat it.
  667.               * Well, perhaps it's a directory and
  668.               * we'll be able to list it anyway.
  669.               * If it isn't or we can't, no harm done. */
  670.              : 0))
  671.           goto top;
  672.  
  673.         if (pfen->patlen == pathead + 1)
  674.           {    /* Listing "foo/?/" -- return this entry */
  675.             /* if it's a directory. */
  676.             if (!stat_is_dir (stbuf))
  677.               {    /* Do directoryp test the hard way */
  678.                 dp = opendir(work);
  679.                 if (!dp) goto top;
  680.                 closedir(dp);
  681.               }
  682.             work[len++] = '/';
  683.             goto winner;
  684.           }
  685.  
  686.         /* >>> Should optimise the case in which the next level */
  687.         /* >>> of directory has no wildcards. */
  688.         dp = opendir(work);
  689. #ifdef DEBUG
  690.         {    char save_end = pattern[pathead];
  691.             pattern[pathead] = 0;
  692.             if_debug2('e', "[e]file_enum:fname='%s', p='%s'\n",
  693.                   work, pattern);
  694.             pattern[pathead] = save_end;
  695.         }
  696. #endif /* DEBUG */
  697.         if (!dp)
  698.           /* Can't list this one */
  699.           goto top;
  700.         else
  701.           {    /* Advance to the next directory-delimiter */
  702.             /* in pattern */
  703.             char *p;
  704.                         dirstack *d;
  705.             for (p = pattern + pathead + 1; ; p++)
  706.               {    if (*p == 0)
  707.                   {    /* No more subdirectories to match */
  708.                     pathead = pfen->patlen;
  709.                     break;
  710.                   }
  711.                 else if (*p == '/')
  712.                   {    pathead = p - pattern;
  713.                     break;
  714.                   }
  715.               }
  716.  
  717.                         /* Push a directory onto the enumeration stack. */
  718.                         d = gs_alloc_struct(pfen->memory, dirstack,
  719.                                             &st_dirstack,
  720.                                             "gp_enumerate_files(pushdir)");
  721.                         if ( d != 0 )
  722.                         {
  723.                           d->next  = pfen->dstack;
  724.                           d->entry = pfen->dirp;
  725.                           pfen->dstack = d;
  726.                         }
  727.                         else
  728.                           DO_NOTHING; /* >>> e_VMerror!!! */
  729.  
  730.             if_debug1('e', "[e]file_enum:Dir pushed '%s'\n",
  731.                   work);
  732.             worklen = len;
  733.             pfen->dirp = dp;
  734.             goto top;
  735.           }
  736.       }
  737.  
  738.  winner:
  739.     /* We have a winner! */
  740.     pfen->worklen = worklen;
  741.     pfen->pathead = pathead;
  742.     memcpy(ptr, work, len);
  743.     return len;
  744. }
  745.  
  746. /* Clean up the file enumeration. */
  747. void
  748. gp_enumerate_files_close(file_enum *pfen)
  749. {    gs_memory_t *mem = pfen->memory;
  750.  
  751.     if_debug0('e', "[e]file_enum:Cleanup\n");
  752.     while (popdir(pfen))    /* clear directory stack */
  753.           DO_NOTHING;
  754.     gs_free_object(mem, (byte *)pfen->work,
  755.                "gp_enumerate_close(work)");
  756.     gs_free_object(mem, (byte *)pfen->pattern,
  757.                "gp_enumerate_files_close(pattern)");
  758.     gs_free_object(mem, pfen, "gp_enumerate_files_close");
  759. }
  760.  
  761. /***************************************************************************/
  762. /*         Functions from ixemul.library source which aren't in Libnix     */
  763. /***************************************************************************/
  764. #ifndef IXEMUL
  765.  
  766. /***************************************************************************/
  767. /*                                     modf.c                              */
  768. /***************************************************************************/
  769. #include <proto/mathieeedoubbas.h>
  770.  
  771. /*
  772.  * modf(value, iptr): return fractional part of value, and stores the
  773.  * integral part into iptr (a pointer to double).
  774.  */
  775.  
  776. double
  777. modf (double value, double *iptr)
  778. {
  779.   /* if value negative */
  780.   if (IEEEDPTst (value) < 0)
  781.     {
  782.       /* in that case, the integer part is calculated by ceil() */
  783.       *iptr = IEEEDPCeil (value);
  784.       return IEEEDPSub (*iptr, value);
  785.     }
  786.   else
  787.     {
  788.  
  789.       /* if positive, we go for the floor() */
  790.       *iptr = IEEEDPFloor (value);
  791.       return IEEEDPSub (value, *iptr);
  792.     }
  793. }
  794. /***************************************************************************/
  795. /*                                     frexp.c                             */
  796. /***************************************************************************/
  797. #if defined(LIBC_SCCS) && !defined(lint)
  798. static char sccsid[] = "@(#)frexp.c    5.2 (Berkeley) 3/9/86";
  799. #endif LIBC_SCCS and not lint
  800.  
  801. #define KERNEL
  802. /*#include "ixemul.h"*/
  803.  
  804. /*
  805.  *    the call
  806.  *        x = frexp(arg,&exp);
  807.  *    must return a double fp quantity x which is <1.0
  808.  *    and the corresponding binary exponent "exp".
  809.  *    such that
  810.  *        arg = x*2^exp
  811.  *    if the argument is 0.0, return 0.0 mantissa and 0 exponent.
  812.  */
  813.  
  814. double
  815. frexp(double x, int *i)
  816. {
  817.   int neg;
  818.   int j;
  819.  
  820.   j = 0;
  821.   neg = 0;
  822.  
  823.   if (x < 0)
  824.     {
  825.       x = -x;
  826.       neg = 1;
  827.     }
  828.  
  829.   if (x >= 1.0)
  830.     while(x >= 1.0)
  831.       {
  832.     j = j+1;
  833.     x = x/2;
  834.       }
  835.   else if(x < 0.5 && x != 0.0)
  836.     while(x < 0.5)
  837.       {
  838.     j = j-1;
  839.     x = 2*x;
  840.       }
  841.  
  842.   *i = j;
  843.   if (neg) x = -x;
  844.   return x;
  845. }
  846.  
  847. /***************************************************************************/
  848. /*                                     ldexp.c                             */
  849. /***************************************************************************/
  850. /*
  851.  * ldexp returns the quanity "value" * 2 ^ "exp"
  852.  *
  853.  * For the mc68000 using IEEE format the double precision word format is:
  854.  *
  855.  * WORD N   =>    SEEEEEEEEEEEMMMM
  856.  * WORD N+1 =>    MMMMMMMMMMMMMMMM
  857.  * WORD N+2 =>    MMMMMMMMMMMMMMMM
  858.  * WORD N+3 =>    MMMMMMMMMMMMMMMM
  859.  *
  860.  * Where:          S  =>   Sign bit
  861.  *                 E  =>   Exponent
  862.  *                 X  =>   Ignored (set to 0)
  863.  *                 M  =>   Mantissa bit
  864.  *
  865.  * NOTE:  Beware of 0.0; on some machines which use excess 128 notation for the
  866.  * exponent, if the mantissa is zero the exponent is also.
  867.  *
  868.  */
  869.  
  870. #define MANT_MASK 0x800FFFFF    /* Mantissa extraction mask     */
  871. #define ZPOS_MASK 0x3FF00000    /* Positive # mask for exp = 0  */
  872. #define ZNEG_MASK 0x3FF00000    /* Negative # mask for exp = 0  */
  873.  
  874. #define EXP_MASK 0x7FF00000    /* Mask for exponent            */
  875. #define EXP_SHIFTS 20        /* Shifts to get into LSB's     */
  876. #define EXP_BIAS 1023        /* Exponent bias                */
  877.  
  878.  
  879. union dtol
  880. {
  881.   double dval;
  882.   int ival[2];
  883. };
  884.  
  885. double
  886. ldexp (value, exp)
  887.      double value;
  888.      int exp;
  889. {
  890.   union dtol number;
  891.   int *iptr, cexp;
  892.  
  893.   if (value == 0.0)
  894.     return (0.0);
  895.   else
  896.     {
  897.       number.dval = value;
  898.       iptr = &number.ival[0];
  899.       cexp = (((*iptr) & EXP_MASK) >> EXP_SHIFTS) - EXP_BIAS;
  900.       *iptr &= ~EXP_MASK;
  901.       exp += EXP_BIAS;
  902.       *iptr |= ((exp + cexp) << EXP_SHIFTS) & EXP_MASK;
  903.       return (number.dval);
  904.     }
  905. }
  906. #endif
  907.